# 7.list 列表数据类型

# 列表类型 (list)

列表是Python的基础数据类型之一，其他编程语言也有类似的数据类型，比如JS中的数组, java中的数组等等

列表是用 [ ] 中括号来表达的，存储列表中的每个元素用 ' ' 单引号隔开，而且可以存放各种数据类型

lst = [1, '哈哈', "吼吼", [1,8,0,"百度"], ("我","叫", "元", "组"), "abc", {"我 叫":"dict字典"},{"我叫集合","集合"}]
print(lst)

执行结果：
[1, '哈哈', '吼吼', [1, 8, 0, '百度'], ('我', '叫', '元', '组'), 'abc', {'我 叫': 'dict字典'}, {'我叫集合', '集合'}]

列表相比于字符串，不仅可以存放不同的数据类型，而且可以存放大量的数据，

32位 python可以存放: 536870912个元素,
64位可以存放: 1152921504606846975个元素

而且列表是有序的(按照你保存的顺序),有索引, 可以切⽚片⽅方便便取值

# 索引

列表跟字符串一样也拥有索引

索引也称为下标，在python中索引也是下标是从0开始

反向索引：python中反向索引是从-1开始

反向索引：-0 等于 0，就是说你获取列表的-0的值，实际就是获取列表的开头值

so = ["江凡","江小凡","江凡凡","凡"]
print(so[3]
      
执行结果：
凡

以上实例，通过索引获取列表中的第3位数据，从0开始算

so = ["江凡","江小凡","江凡凡","凡"]
print(so[-2])

执行结果：
江凡凡

以上实例，通过反向索引获取列表中的反向第二位数据，从-1开始算

# 更改列表数据

列表数据是可以发生改变的

在字符串中就不可以使用这种方式来更改字符串内容

so = ["江凡","江小凡","江凡凡","凡"]
so[3] = "你好"
print(so[3])
print(so)

执行结果：
你好
['江凡', '江小凡', '江凡凡', '你好']

以上实例，可以通过指定要修改的那块数据，进行重新赋值

# 切片

切片可以对列表进行截取取值，从0开始，反向切片从-1开始

反向切片，默认是从左向右切

特点：起始值可取，结束值不可取

格式：变量[起始位置 : 结束位置]

so = ["江凡","江小凡","江凡凡","凡"]
print(so[1:3])

执行结果：
['江小凡', '江凡凡']

以上实例：通过获取，起始位置为：1 结束位置为：3的值

so = ["江凡","江小凡","江凡凡","凡"]
print(so[0:2] + so[1:3])

执行结果：
['江凡', '江小凡', '江小凡', '江凡凡']

以上实例：能过 + 运算符，把两边的数据合并起来为一个列表

so = ["江凡","江小凡","江凡凡","凡"]
print(so[:2])

执行结果：
['江凡', '江小凡']

以上实例，如果起始位置不填，默认从开头开始

so = ["江凡","江小凡","江凡凡","凡"]
print(so[2:])

执行结果：
['江凡凡', '凡']

以上实例，如果结束位置不填，默认到结尾

so = ["江凡","江小凡","江凡凡","凡"]
print(so[:])

执行结果：
['江凡', '江小凡', '江凡凡', '凡']

以上实例，如果起始跟结束位置都不填写，默认从头到尾执行

# 反向切片

反向切片，默认是从左向右切

特点：起始值可取，结束值不可取

格式：变量[起始位置 : 结束位置]

so = ["江凡","江小凡","江凡凡","凡"]
print(so[-3:-1])

执行结果：
['江小凡', '江凡凡']

# 步长

步长，可以在指定范围内，每几个取一个值

取值，取范围中的开头值

反向步长，以右向左方向取值

格式：变量[起始位置 : 结束位置 : 步长]

so = ["江凡","江小凡","江凡凡","凡"]
print(so[::2])

执行结果：
['江凡', '江凡凡']

以上实例：每走二步，取一个值

so = ["江凡","江小凡","江凡凡","凡"]
print(so[::-2])

执行结果：
['凡', '江小凡']

以上实例：反向步长，反向取值

# 列表的增删改查

# 增加

列表类型跟字符串类型是不一样的

字符串：是不可变的对象，所有任何操作对原字符串是不会有任何的影响
列表：是可以发生改变. 所以直接就在原来的对象上进行了操作

# 增加 - append()

给一个列表增加值，从结尾处增加，一次只能增加一个值

格式：列表变量.append("值")

so = ["麻花藤", "林林俊杰", "周润发", "周芷若"]
print(so)
so.append("你好")
print(so)

执行结果：
['麻花藤', '林林俊杰', '周润发', '周芷若']
['麻花藤', '林林俊杰', '周润发', '周芷若', '你好']

# 实例：录入员工信息

要求使用append()函数，实现模拟录入员工信息功能

user = []
while 1:
    user_so = input("请输入要录入的员工姓名，按 Q 键退出：")
    if user_so.upper() == "Q":
        break
    user.append(user_so)
    print(user)

# 指定位置增加 - insert()

指定位置中增加值，以0开始，0为开头位置

格式：列表变量.insert(位置,"值")

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.insert(1,"你好")
print(so)

执行结果：
['麻花藤', '你好', '林俊杰', '周润发', '周芷若']

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.insert(-1,"你好")
print(so)

执行结果：
['麻花藤', '林俊杰', '周润发', '你好', '周芷若']

以上实例，反向增加

# 迭代添加 - extend()

增加多值到列表中，从结尾处增加

格式：列表变量.extend(["值","值"])

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.extend(["你好","世界"])
print(so)

执行结果：
['麻花藤', '林俊杰', '周润发', '周芷若', '你好', '世界']

# 删除

# 指定位置删除 - pop()

通过指定值的位置来进行删除，如果不填位置，默认删除最后一个

以 0 开始算，0 为开头位置

格式：列表变量.pop(位置值)

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.pop()
print(so)

执行结果：
['麻花藤', '林俊杰', '周润发']

以上实例，不填写位置值，默认删除最后一个

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.pop(1)
print(so)

执行结果：
['麻花藤', '周润发', '周芷若']

以上实例，删除位置为1 的值

# 获取删除的值- pop()

格式：变量 = 列表变量.pop(位置值)

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
soo = so.pop(1)
print("删除的值：",soo)
print(so)

执行结果：
删除的值： 林俊杰
['麻花藤', '周润发', '周芷若']

# 指定值删除 - remove()

指定值来进行删除，如果删除不存在的值会报错

格式：列表变量.remove(值)

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.remove("周润发")
print(so)

执行结果：
['麻花藤', '林俊杰', '周芷若']

# 实例：使用for循环清空列表

直接使用for循环是不可行的，因为for运行过程中会有一个指针来记录当前循环的元素是哪一个，如果使用for循环直接删除那么for循环一开始这个指针指向第0个，然后获取到第0个的元素，紧接着删除第0个，这个时候，原来排行为1的元素就会自动变成0，因为排行为0的元素已经消失了，然后for循环的指针在指定第1元素，这时原来的1已经变成0，也就是不会被删除了，所以直接使用for循环删除是不可行的。

注意：由于删除元素会导致元素的索引(位置) 发生改变，所以容易出现问题，尽量不要再循环中直接去删除元素，可以把要删除的元素添加到另一个列表中，然后在循环删除

so = [1,2,3,4,5,6,7,8,9]
for i in so:
    so.remove(i)
print(so)

执行结果：
[2, 4, 6, 8]

以上实例，直接使用for循环删除全列表就会出现只能删除一半数据

# 实例：删除指定的元素

有一个列表：["周杰伦","周海媚","周星星","马云","周树人"]，删除所有姓周的人

so = ["周杰伦","周海媚","周星星","马云","周树人"]
wo = []
for i in so:
    if i[0] == "周":
        wo.append(i)
for i in wo:
    so.remove(i)
print(so)

执行结果：
['马云']

解决方案1

so = [1,2,3,4,5,6,7,8,9]
wo = []
for i in so:
    wo.append(i)
for i in wo:
    so.remove(i)
print(so)

执行结果：
[]

以上实例，使用二个for循环，先把要删除的值赋值到另一个列表中，在删除原来的值

解决方案2

so = ["周杰伦","周海媚","周星星","马云","周树人"]
for i in range(0,len(so)):
    so.pop()
print(so)

执行结果：
[]

# 清空列表 - clear()

清空列表的全部数据

格式：列表变量.clear()

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so.clear()
print(so)

执行结果：
[]

# 切片删除 - del

指定范围内删除，以0开始，0为开头位置

特点：起始值可取，结束值不可取

格式：del 列表变量[起始位置 : 结束位置]

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
del so[1:3]
print(so)

执行结果：
['麻花藤', '周芷若']

# 修改

按位置值进行修改

格式：列表变量[位置值] = "值"

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so[3] = "你好"
print(so)

执行结果：
['麻花藤', '林俊杰', '周润发', '你好']

以上实例：把3号值修改成你好

# 切片修改

按范围进行修改，以0开始，0为开头位置

特点：起始值可取，结束值不可取

格式：列表变量[起始位置 : 结束位置] = ["值","值"]

so = ["麻花藤", "林俊杰", "周润发", "周芷若"]
so[1:2] = ["你好","世界","世界"]
print(so)

执行结果：
['麻花藤', '你好', '世界', '世界', '周润发', '周芷若']

以上实例，将第1号跟第2号值修改成 "你好","世界","世界" 这三个值

# 步长

步长，可以在指定范围内，每几个取一个值

取值，取范围中的开头值

格式：列表变量[起始位置 : 结束位置 : 步长] = ["值","值"]

so = ["麻花藤", "林俊杰", "周润发", "周芷若","码云"]
so[1:4:2] = ["你好","世界"]
print(so)

执行结果：
['麻花藤', '你好', '周润发', '世界', '码云']

以上实例，切片修改也OK，如果步长不是1，要注意，元素的个数，如果切片没有步长或步长是1，则不用关心个数

# 查询

查询列表可以使用for循环查询，因列表是一个可迭代对象

so = ["麻花藤", "林俊杰", "周润发", "周芷若","码云"]
for io in so:
    print(io)

执行结果：
麻花藤
林俊杰
周润发
周芷若
码云

# 剩余常用操作

# 查询指定值出现的次数 - count()

查询指定的值在列表中出现的次数

格式：变量.count(值) 或变量 = 变量.count(值)

so = ["码云","麻花藤", "林俊杰", "周润发", "周芷若","码云"]
print(so.count("码云"))

执行结果：
2

# 排序操作 - sort()

对列表中的所有值进行排序操作，默认是进行升序操作

如果列表中有字符串跟整数，就不能进行排序，不然会报错

格式：

列表变量.sort()

so = [10,8,4,7,2,9,6,1,3]
so.sort()
print(so)

执行结果：
[1, 2, 3, 4, 6, 7, 8, 9, 10]

以上实例，使用升序操作

列表变量.sort(reverse=True)

so = [10,8,4,7,2,9,6,1,3]
so.sort(reverse=True)
print(so)

执行结果：
[10, 9, 8, 7, 6, 4, 3, 2, 1]

以上实例，使用降序排序

# 反向查询 - reverse()

反向查询列表输出

格式：列表变量.reverse()

so = ["码云","麻花藤", "林俊杰", "周润发", "周芷若","码云"]
so.reverse()
print(so)

执行结果：
['码云', '周芷若', '周润发', '林俊杰', '麻花藤', '码云']

# 查询列表的长度 - len()

查询列表有几个值组成

格式：变量 = len(变量)

so = ["码云","麻花藤", "林俊杰", "周润发", "周芷若","码云"]
so = len(so)
print(so)

执行结果：
6

# 列表的嵌套

采用降维操作，建议从上看到下

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]

# 找到msg

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
print(so[2])

执行结果：
msg

# 找到码云跟msg

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
print(so[1:3])

执行结果：
['码云', 'msg']

# 找到码云的码字

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
print(so[1][0])

执行结果:
码

# 将msg拿到，进行首字母大写，后在写回去

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
wo = so[2].capitalize()
so[2] = wo
print(so)

执行结果：
[8, '码云', 'Msg', ['麻花藤', ['百事可乐'], '周润发']]

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[2] = so[2].capitalize()
print(so)

执行结果：
[8, '码云', 'Msg', ['麻花藤', ['百事可乐'], '周润发']]

# 码云换成马云

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[1] = "马云"
print(so)

执行结果：
[8, '马云', 'msg', ['麻花藤', ['百事可乐'], '周润发']]

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[1] = so[1].replace("码","马")
print(so)

执行结果：
[8, '马云', 'msg', ['麻花藤', ['百事可乐'], '周润发']]

# 把麻花藤换成马化腾

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[3][0] = so[3][0].replace("麻花藤","马化腾")
print(so[3][0])

执行结果：
马化腾

因为列表中还有小列表，如果有小列表在主列表中就会把小列表认为是一个值中

# 把百事可乐换成可口可乐

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[3][1][0] = so[3][1][0].replace("百事","可口")
print(so[3][1][0])
print(so)

执行结果：
可口可乐
[8, '码云', 'msg', ['麻花藤', ['可口可乐'], '周润发']]

# 在百事可乐后面加上可口可乐

so = [8, "码云", "msg", ["麻花藤", ["百事可乐"], "周润发"]]
so[3][1].append("可口可乐")
print(so)

执行结果：
[8, '码云', 'msg', ['麻花藤', ['百事可乐', '可口可乐'], '周润发']]

← 6.str字符串数据类型 8.tuple 元组数据类型 →